package com.hp.ams.ongoing.netatendimento.infrastructure.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.hp.ams.ongoing.netatendimento.infrastructure.exception.DataBaseAcessException;
import com.hp.ams.ongoing.netatendimento.infrastructure.persistence.MongoDbRepository;
import com.hp.ams.ongoing.netatendimento.model.entity.Categorizacao;
import com.hp.ams.ongoing.netatendimento.model.entity.CausaAssociada;
import com.hp.ams.ongoing.netatendimento.model.entity.Cidade;
import com.hp.ams.ongoing.netatendimento.model.entity.GrupoExecucao;
import com.hp.ams.ongoing.netatendimento.model.entity.GrupoExecucaoCategorizacao;
import com.hp.ams.ongoing.netatendimento.model.entity.RetornoScriptExecucao;
import com.hp.ams.ongoing.netatendimento.model.entity.ScriptExecucao;
import com.hp.ams.ongoing.netatendimento.model.entity.TipoRegistro;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;

public final class DataRepositoryConverter {

	
	public static List convertDBCursorToList(DBCursor cursor, Class clazz) throws DataBaseAcessException{
		List list = null;
		if (clazz == GrupoExecucao.class){
			list = convertGrupoExecucao(cursor, clazz);
		}else if (clazz == ScriptExecucao.class){
			list = convertScriptExecucao(cursor, clazz);
		}else if (clazz == RetornoScriptExecucao.class){
			list = convertRetornoExecucao(cursor, clazz);
		}else if (clazz == TipoRegistro.class){
			list = convertTipoRegistro(cursor, clazz);
		}else if (clazz == Cidade.class){
			list = convertCidade(cursor, clazz);
		}else if (clazz == Categorizacao.class){
			list = convertCategorizacao(cursor, clazz);
		}
		else if (clazz == GrupoExecucaoCategorizacao.class){
			list = convertGrupoCategorizacao(cursor, clazz);
		}
		System.out.print("\n\n Entidade convertida : "+clazz.getCanonicalName()+ " \n");
		System.out.print("Valores :");
		for (int i = 0; i < list.size(); i++) {
			System.out.print(" \n"+list.get(i));
		}
		System.out.println();
		return list;
	}
	
	private static List convertGrupoExecucao(DBCursor cursor, Class clazz) throws DataBaseAcessException{
		List<GrupoExecucao> grupos = new ArrayList<GrupoExecucao>();
		GrupoExecucao grupo = null;
		GrupoExecucao grupoPai = null;
		DBObject obj = null;
		Map<String,Object> map = new HashMap<String, Object>();
		while (cursor.hasNext()) {
			grupo = new GrupoExecucao();			
			obj = cursor.next();
			grupo.setIdGrupoExecucao((Integer) obj.get("id_grupo_execucao"));
			grupo.setDsGrupoExecucao((String) obj.get("ds_grupo_execucao"));
			if ( obj.get("id_grupo_pai")!=null){
				grupoPai = new GrupoExecucao();
				map.put("id_grupo_execucao", obj.get("id_grupo_pai"));
				BasicDBObject pai = (BasicDBObject) MongoDbRepository.getInstance().findDbObject(clazz, map);				
				grupoPai.setIdGrupoExecucao((Integer) pai.get("id_grupo_execucao"));
				grupoPai.setDsGrupoExecucao((String) pai.get("ds_grupo_execucao"));
				grupo.setGrupoExecucaoPai(grupoPai);
			}
			grupos.add(grupo);
		}
		return grupos;		
	}
	
	private static List convertRetornoExecucao(DBCursor cursor, Class clazz) throws DataBaseAcessException{
		List<RetornoScriptExecucao> lstRetorno = new ArrayList<RetornoScriptExecucao>();
		RetornoScriptExecucao retorno = null;
		CausaAssociada causa = null;
		DBObject obj = null;
		Map<String,Object> map = new HashMap<String, Object>();
		while (cursor.hasNext()) {
			retorno = new RetornoScriptExecucao();			
			obj = cursor.next();
			retorno.setIdRetorno((Integer) obj.get("id_retorno"));									
				causa = new CausaAssociada();
				map.put("id_causa", obj.get("id_causa_associada"));
				BasicDBObject causaObj = (BasicDBObject) MongoDbRepository.getInstance().findDbObject(CausaAssociada.class, map);				
				causa.setDescricaoCausa((String) causaObj.get("ds_causa"));
				causa.setUrlToDocument((String) causaObj.get("url_doc"));		
				retorno.setCausa(causa);
				lstRetorno.add(retorno);
			}
		
		return lstRetorno;		
	}
	
	private static List convertScriptExecucao(DBCursor cursor, Class clazz) throws DataBaseAcessException{
		List<ScriptExecucao> scripts = new ArrayList<ScriptExecucao>();
		ScriptExecucao script = null;
		GrupoExecucao grupo = null;
		DBObject obj = null;
		Map<String,Object> map = new HashMap<String, Object>();
		while (cursor.hasNext()) {
			script = new ScriptExecucao();			
			obj = cursor.next();
			script.setIdScripExecucao((Integer) obj.get("id_script_execucao"));
			script.setDsScriptExecucao((String) obj.get("ds_script_execucao"));
			script.setCorpoScript((String) obj.get("corpo_script"));
			script.setQtdParametros((Integer) obj.get("qtd_parametro"));
			script.setOrdem((Integer) obj.get("id_ordem"));						
				grupo = new GrupoExecucao();
				map.put("id_grupo_execucao", obj.get("id_grupo_execucao"));
				BasicDBObject grupoExec = (BasicDBObject) MongoDbRepository.getInstance().findDbObject(GrupoExecucao.class, map);				
				grupo.setIdGrupoExecucao((Integer) grupoExec.get("id_grupo_execucao"));
				grupo.setDsGrupoExecucao((String) grupoExec.get("ds_grupo_execucao"));	
				script.setGrupoExecucao(grupo);
				scripts.add(script);
			}
		
		return scripts;		
	}
	
	private static List convertTipoRegistro(DBCursor cursor, Class clazz) {
		List<TipoRegistro> tipos = new ArrayList<TipoRegistro>();
		TipoRegistro tipoRegr = null;
		DBObject obj = null;
		while (cursor.hasNext()) {
			tipoRegr = new TipoRegistro();			
			obj = cursor.next();
			tipoRegr.setIdTipoRegistro((Integer) obj.get("id_tipo_registro"));
			tipoRegr.setDsTipoRegistro((String) obj.get("ds_tipo_registro"));
			tipos.add(tipoRegr);
		}		
		return tipos;
	}
	
	private static List convertCategorizacao(DBCursor cursor, Class clazz) {
		List<Categorizacao> cats = new ArrayList<Categorizacao>();
		Categorizacao cat = null;
		DBObject obj = null;
		while (cursor.hasNext()) {
			cat = new Categorizacao();			
			obj = cursor.next();
			cat.setIdCategoria((Integer) obj.get("id_categoria"));
			cat.setDsCategoria((String) obj.get("ds_categoria"));
			cats.add(cat);
		}		
		return cats;
	}
	
	private static List convertCidade(DBCursor cursor, Class clazz) {
		List<Cidade> cidades = new ArrayList<Cidade>();
		Cidade cidade = null;
		DBObject obj = null;
		while (cursor.hasNext()) {
			cidade = new Cidade();			
			obj = cursor.next();			
			cidade.setAliasBase((String) obj.get("alias_base"));
			cidade.setNomeCidade((String) obj.get("ci_nome"));
			cidade.setCodOperadora((String) obj.get("cid_contrato"));
			cidade.setCidContrato((String) obj.get("cod_operadora"));
			cidade.setIdEmpresa((String) obj.get("id_empresa"));
			cidades.add(cidade);
		}		
		return cidades;
	}
	
	private static List convertGrupoCategorizacao(DBCursor cursor, Class clazz) throws DataBaseAcessException {
		List<GrupoExecucaoCategorizacao> grupoCats = new ArrayList<GrupoExecucaoCategorizacao>();
		GrupoExecucaoCategorizacao grupoCat = null;
		Categorizacao cat = null;
		GrupoExecucao grupo = null;
		DBObject obj = null;
		Map<String,Object> map = new HashMap<String,Object>();		
		while (cursor.hasNext()) {
			map.clear();
			grupoCat = new GrupoExecucaoCategorizacao();
			obj = cursor.next();	
			map.put("id_categoria", (Integer) obj.get("id_categoria"));
			List lsts = MongoDbRepository.getInstance().findByQuery(Categorizacao.class, map);
			cat = (Categorizacao) lsts.get(0);
			map.clear();
			map.put("id_grupo_execucao", (Integer) obj.get("id_grupo_execucao"));
			List lsts2 = MongoDbRepository.getInstance().findByQuery(GrupoExecucao.class, map);
			grupo = (GrupoExecucao) lsts2.get(0);
			
			grupoCat.setCatetorizacao(cat);
			grupoCat.setGrupoExecucao(grupo);
			grupoCats.add(grupoCat);
		}		
		return grupoCats;
	}
	
	
}
